home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / tools / disk-tools / hdsleep / source / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-26  |  15.0 KB  |  665 lines
  1. /*
  2. ** includes
  3. */
  4.  
  5. #include<dos.h>
  6. #include<stdio.h>
  7. #include<string.h>
  8. #include<stdlib.h>
  9. #include<proto/dos.h>
  10. #include<proto/exec.h>
  11. #include<proto/icon.h>
  12. #include<proto/commodities.h>
  13. #include<proto/intuition.h>
  14. #include<proto/gadtools.h>
  15. #include<exec/io.h>
  16. #include<exec/memory.h>
  17. #include<exec/interrupts.h>
  18. #include<exec/execbase.h>
  19. #include<exec/devices.h>
  20. #include<dos/rdargs.h>
  21. #include<devices/timer.h>
  22. #include"hdsleep_rev.h"
  23. #include"gadtools.h"
  24.  
  25. /*
  26. ** version
  27. */
  28.  
  29. char    ver[]=VERSTAG;
  30.  
  31. /*
  32. ** defines
  33. */
  34.  
  35. #define TYPE_RUN 0
  36. #define TYPE_END 1
  37. #define TYPE_SPINUP 2
  38. #define TYPE_SPINDOWN 3
  39. #define TYPE_HOTKEY 4
  40.  
  41. #define TEMPLATE "CX_PRIORITY/N/K,CX_POPKEY/K,CX_POPUP/K,HDSLEEPKEY=SKEY/K,MASTERTIME=MT/N,SLAVETIME=ST/N,WARNING=WARN/S,WARNINGTIMEOUT=WT/N,LOGFILE=L/K,A4000/S"
  42. #define ARG_PRIORITY        0
  43. #define ARG_POPKEY            1
  44. #define ARG_POPUP                2
  45. #define ARG_HDSLEEPKEY    3
  46. #define ARG_MASTERTIME    4
  47. #define ARG_SLAVETIME        5
  48. #define ARG_WARNING            6
  49. #define ARG_WARNINGTO        7
  50. #define ARG_LOGFILE            8
  51. #define ARG_A4000                9
  52. #define ARG_COUNT                10
  53.  
  54. #define OFF 0
  55. #define ON 1
  56. #define STOPPED 2
  57. #define EVT_POPKEY 1
  58. #define EVT_HOTKEY 2
  59. #define DRV_MASTER 0
  60. #define DRV_SLAVE 1
  61.  
  62. #define    unless(x) if ( !(x) )
  63. #define LEAVE goto exitit
  64.  
  65. ULONG DEF_PRIORITY=0;
  66. char    DEF_POPKEY[]="control alt h";
  67. char    DEF_POPUP2[]="YES";
  68. ULONG DEF_POPUP=1;
  69. char    DEF_HDSLEEPKEY[]="control h";
  70. ULONG DEF_MASTERTIME=360;    // 360 secs == 4 mins
  71. ULONG DEF_SLAVETIME=0;      // 360 secs == 4 mins
  72. ULONG DEF_WARNING=0;
  73. ULONG DEF_WARNINGTO=5;
  74. char DEF_LOGFILE[]="\0";
  75. ULONG DEF_A4000=FALSE;
  76.  
  77. /*
  78. ** prototypes
  79. */
  80.  
  81. void    main(int, char **);
  82. void    __saveds __asm MyBeginIO(register __a1 struct IORequest *);
  83. int        AddInt(void);
  84. void    RemInt(void);
  85. void    HandleCxMsg(void);
  86. void    RequestOK(char *);
  87. APTR    BusyWindow(struct Window *);
  88. void    UnbusyWindow(APTR);
  89. void    LogFile(UBYTE,UBYTE);
  90.  
  91. extern struct DiskObject *TTGetOurIcon(struct WBStartup *);
  92. extern void TTFreeOurIcon(struct DiskObject *);
  93. extern char *TTString(struct DiskObject *,char *, char *);
  94. extern LONG TTInt(struct DiskObject *,char *, LONG);
  95. extern int TTBool(struct DiskObject *,char *, BOOL);
  96.  
  97. //extern    void SPrintf(char *,const char *, ...);
  98. extern    void __asm CallBeginIO(register __a1 struct IORequest *);
  99. extern    void __asm HDDriveOff(register __d0 UBYTE);
  100. extern    UBYTE __asm CheckHD(register __d0 UBYTE);
  101.  
  102. /*
  103. ** variables
  104. */
  105.  
  106. extern struct ExecBase *SysBase;
  107. APTR OldBeginIO=NULL;
  108. struct DiskObject *icon=NULL;
  109. struct Library *SCSIBase=NULL;
  110. struct MsgPort *TimerPort=NULL;
  111. struct timerequest TimerReq;
  112. struct IntuiMessage *message;
  113. struct Gadget *gadget;
  114. struct MenuItem *item;
  115. BOOL running=TRUE,timerun=FALSE,POPUP=TRUE;//,SpinUp=FALSE;
  116. ULONG MASTERTIME,SLAVETIME,signals,MasterTime=0,SlaveTime=0,class,code;
  117. ULONG SigWin,WARNING=0,WARNINGTO,Computer=0;
  118. UBYTE MasterHD,SlaveHD;
  119.  
  120. struct BusyWin
  121. {
  122.     struct Requester Req;
  123.     struct Window *Win;
  124. };
  125.  
  126. /*
  127. ** commodities
  128. */
  129.  
  130. struct NewBroker newbroker=
  131. {
  132.     NB_VERSION,
  133.     "HDSleep",
  134.     "HDSleep v1.2 by Thom/Union",
  135.     "HD noise saver for A1200/A4000",
  136.     NBU_UNIQUE|NBU_NOTIFY,
  137.     COF_SHOW_HIDE
  138. };
  139.  
  140. struct MsgPort *broker_mp=NULL;
  141. CxObj *broker=NULL, *hdsleepobj, *popkeyobj;
  142. CxMsg *cxmsg;
  143. ULONG msgid, msgtype;
  144. UBYTE hdsleepstr[50],popkeystr[50],logfilestr[108];
  145.  
  146. /*
  147. ** functions
  148. */
  149.  
  150. void main(int argc,char *argv[])
  151. {
  152.     struct RDArgs *rdargs;
  153.     long *(opts[ARG_COUNT]),arg;
  154.     struct Node *SCSINode;
  155.     struct IORequest SCSIIOReq;
  156.     struct MsgPort SCSIPort;
  157.  
  158.     if(SysBase->LibNode.lib_Version<39)
  159.     {
  160.         RequestOK("You must have\nAmiga with OS3.0");
  161.         LEAVE;
  162.     }
  163.     MasterHD=TRUE;    // MasterHD=CheckHD(DRV_MASTER);
  164.     SlaveHD=TRUE;    // SlaveHD=CheckHD(DRV_SLAVE);
  165.  
  166.     if(argc!=0)
  167.     {
  168.         opts[ARG_PRIORITY]=&DEF_PRIORITY;
  169.         opts[ARG_POPKEY]=(long *)DEF_POPKEY;
  170.         opts[ARG_POPUP]=(long *)DEF_POPUP2;
  171.         opts[ARG_HDSLEEPKEY]=(long *)DEF_HDSLEEPKEY;
  172.         opts[ARG_MASTERTIME]=&DEF_MASTERTIME;
  173.         opts[ARG_SLAVETIME]=&DEF_SLAVETIME;
  174.         opts[ARG_WARNING]=(long *)DEF_WARNING;
  175.         opts[ARG_WARNINGTO]=&DEF_WARNINGTO;
  176.         opts[ARG_LOGFILE]=(long *)DEF_LOGFILE;
  177.         opts[ARG_A4000]=(long *)DEF_A4000;
  178.  
  179.         if(rdargs=ReadArgs(TEMPLATE,(long *) opts, NULL))
  180.         {
  181.             arg=FindArg(TEMPLATE,"CX_PRIORITY");
  182.             if(arg>-1)
  183.                 newbroker.nb_Pri=*opts[arg];
  184.  
  185.             arg=FindArg(TEMPLATE,"CX_POPUP");
  186.             if(arg>-1)
  187.             {
  188.                 if(!stricmp((char *)opts[arg],"NO")) POPUP=FALSE;
  189.                 if(!stricmp((char *)opts[arg],"FALSE")) POPUP=FALSE;
  190.                 if(!stricmp((char *)opts[arg],"OFF")) POPUP=FALSE;
  191.             }
  192.  
  193.             arg=FindArg(TEMPLATE,"CX_POPKEY");
  194.             if(arg>-1)
  195.                 strcpy(popkeystr,(char *)opts[arg]);
  196.  
  197.             arg=FindArg(TEMPLATE,"HDSLEEPKEY");
  198.             if(arg>-1)
  199.                 strcpy(hdsleepstr,(char *)opts[arg]);
  200.  
  201.             arg=FindArg(TEMPLATE,"MASTERTIME");
  202.             if(arg>-1)
  203.                 MASTERTIME=*opts[arg];
  204.  
  205.             arg=FindArg(TEMPLATE,"SLAVETIME");
  206.             if(arg>-1)
  207.                 SLAVETIME=*opts[arg];
  208.  
  209.             arg=FindArg(TEMPLATE,"WARNING");
  210.             if(arg>-1)
  211.                 WARNING=(ULONG)opts[arg];
  212.  
  213.             arg=FindArg(TEMPLATE,"WARNINGTIMEOUT");
  214.             if(arg>-1)
  215.                 WARNINGTO=*opts[arg];
  216.  
  217.             arg=FindArg(TEMPLATE,"LOGFILE");
  218.             if(arg>-1)
  219.                 strcpy(logfilestr,(char *)opts[arg]);
  220.  
  221.             arg=FindArg(TEMPLATE,"A4000");
  222.             if(arg>-1)
  223.                 Computer=(ULONG)opts[arg];
  224.  
  225.             FreeArgs(rdargs);
  226.         }
  227.         else
  228.         {
  229.             PrintFault(IoErr(),argv[0]);
  230.             LEAVE;
  231.         }
  232.     }
  233.     else
  234.     {
  235.         unless(icon=TTGetOurIcon(WBenchMsg)) icon=GetDiskObject(argv[0]);
  236.         newbroker.nb_Pri=TTInt(icon,"CX_PRIORITY",DEF_PRIORITY);
  237.         strcpy(popkeystr,TTString(icon,"CX_POPKEY",DEF_POPKEY));
  238.         POPUP=TTBool(icon,"CX_POPUP",DEF_POPUP);
  239.         strcpy(hdsleepstr,TTString(icon,"HDSLEEPKEY",DEF_HDSLEEPKEY));
  240.         MASTERTIME=TTInt(icon,"MASTERTIME",DEF_MASTERTIME);
  241.         SLAVETIME=TTInt(icon,"SLAVETIME",DEF_SLAVETIME);
  242.         WARNING=TTBool(icon,"WARNING",DEF_WARNING);
  243.         WARNINGTO=TTInt(icon,"WARNINGTIMEOUT",DEF_WARNINGTO);
  244.         strcpy(logfilestr,TTString(icon,"LOGFILE",DEF_LOGFILE));
  245.         Computer=(ULONG) TTBool(icon,"A4000",DEF_A4000);
  246.         TTFreeOurIcon(icon);
  247.     }
  248.  
  249.     if(MASTERTIME==0) MasterHD=FALSE;
  250.     if(SLAVETIME==0) SlaveHD=FALSE;
  251.  
  252.     MasterTime=MASTERTIME;
  253.     SlaveTime=SLAVETIME;
  254.  
  255.     unless(broker_mp=CreateMsgPort()) LEAVE;
  256.     newbroker.nb_Port=broker_mp;
  257.     unless(broker=CxBroker(&newbroker,NULL)) LEAVE;
  258.     unless(hdsleepobj=HotKey(hdsleepstr,broker_mp,EVT_HOTKEY)) LEAVE;
  259.     unless(popkeyobj=HotKey(popkeystr,broker_mp,EVT_POPKEY)) LEAVE;
  260.     AttachCxObj(broker,hdsleepobj);
  261.     if(CxObjError(hdsleepobj)) LEAVE;
  262.     AttachCxObj(broker,popkeyobj);
  263.     if(CxObjError(popkeyobj)) LEAVE;
  264.     ActivateCxObj(broker,1L);
  265.  
  266. // Get scsi.device base address
  267.  
  268.     unless(SCSINode=FindName(&SysBase->DeviceList,"scsi.device")) LEAVE;
  269.     AddPort(&SCSIPort);
  270.     SCSIIOReq.io_Message.mn_ReplyPort=&SCSIPort;
  271.     if(OpenDevice("scsi.device",0L, &SCSIIOReq,0L)) LEAVE;
  272.     SCSIBase=&SCSIIOReq.io_Device->dd_Library;
  273.     CloseDevice(&SCSIIOReq);
  274.     RemPort(&SCSIPort);
  275.  
  276. // Replace BeginIO
  277.  
  278.     Forbid();
  279.     SumLibrary(SCSIBase);
  280.     unless(OldBeginIO=SetFunction(SCSIBase,DEV_BEGINIO,(unsigned long (*)())MyBeginIO)) LEAVE;
  281.     SumLibrary(SCSIBase);
  282.     Permit();
  283.  
  284.     unless(timerun=AddInt()) LEAVE;
  285.  
  286.     SigWin=NULL;
  287.  
  288.     if(POPUP)
  289.     {
  290.         if(!SetupScreen())
  291.         {
  292.             if(!OpenMainWindow())
  293.             {
  294.                 SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  295.                 GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  296.                 GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  297.             }
  298.         }
  299.     }
  300.  
  301.     LogFile(TYPE_RUN,0);
  302.  
  303.     while(running)
  304.     {
  305.         signals=Wait(SIGBREAKF_CTRL_C | (1L<<broker_mp->mp_SigBit) | SigWin | 1L<<TimerPort->mp_SigBit);
  306.         if(signals & (1L<<TimerPort->mp_SigBit))
  307.         {
  308.             if(MainWnd)
  309.             {
  310.                 GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  311.                 GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  312.             }
  313. //            if(SpinUp)
  314. //            {
  315. //                LogFile(TYPE_SPINUP,0);
  316. //                SpinUp=FALSE;
  317. //            }
  318.             if(MasterTime>0 && MasterHD)
  319.             {
  320.                 MasterTime--;
  321.                 if(MasterTime==0)
  322.                 {
  323.                     LogFile(TYPE_SPINDOWN,0);
  324.                     MasterTime=0;
  325.                     HDDriveOff(DRV_MASTER);
  326.                     if(MainWnd)
  327.                     {
  328.                         CloseMainWindow();
  329.                         CloseDownScreen();
  330.                         SigWin=NULL;
  331.                     }
  332.                 }
  333.             }
  334.             if(SlaveTime>0 && SlaveHD)
  335.             {
  336.                 SlaveTime--;
  337.                 if(SlaveTime==0)
  338.                 {
  339.                     LogFile(TYPE_SPINDOWN,1);
  340.                     SlaveTime=0;
  341.                     HDDriveOff(DRV_SLAVE);
  342.                     if(MainWnd)
  343.                     {
  344.                         CloseMainWindow();
  345.                         CloseDownScreen();
  346.                         SigWin=NULL;
  347.                     }
  348.                 }
  349.             }
  350.             TimerReq.tr_time.tv_secs=1;
  351.             TimerReq.tr_time.tv_micro=0;
  352.             SendIO((struct IORequest *) &TimerReq);
  353.             if(WARNING && (SlaveTime==WARNINGTO || MasterTime==WARNINGTO) && !MainWnd)
  354.             {
  355.                 if(!SetupScreen())
  356.                 {
  357.                     if(!OpenMainWindow())
  358.                     {
  359.                         SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  360.                     }
  361.                 }
  362.             }
  363.         }
  364.         if(signals & SIGBREAKF_CTRL_C) running=FALSE;
  365.         if(signals & SigWin)
  366.         {
  367.             while(message=GT_GetIMsg(MainWnd->UserPort))
  368.             {
  369.                 class=message->Class;
  370.                 code=message->Code;
  371.                 gadget=(struct Gadget *)message->IAddress;
  372.                 GT_ReplyIMsg(message);
  373.                 switch(class)
  374.                 {
  375.                     case IDCMP_CLOSEWINDOW:
  376.                         goto gdhide;
  377.                         break;
  378.                     case IDCMP_MENUPICK:
  379.                         while(code!=MENUNULL) 
  380.                         {
  381.                             item=(struct MenuItem *)ItemAddress(MainMenus,code);
  382.                             switch(ITEMNUM(code))
  383.                             {
  384.                                 case 0: goto gdsleep; break;
  385.                                 case 1: goto gdabort; break;
  386.                                 case 3: RequestOK("HDSleep v1.2\n"\
  387.                                                         "     by     \n"\
  388.                                                         " Thom/Union \n"\
  389.                                                         "            \n"\
  390.                                                         "This program\n"\
  391.                                                         "is  FREEWARE");
  392.                                     break;
  393.                                 case 5: goto gdhide; break;
  394.                                 case 6: goto gdquit; break;
  395.                             }
  396.                             code = item->NextSelect;
  397.                         }
  398.                         break;
  399.                     case IDCMP_VANILLAKEY:
  400.                         switch(code)
  401.                         {
  402.                             case 's':
  403.                             case 'S': goto gdsleep; break;
  404.                             case 'a':
  405.                             case 'A': goto gdabort; break;
  406.                             case 'q':
  407.                             case 'Q': goto gdquit; break;
  408.                         }
  409.                         break;
  410.                     case IDCMP_GADGETUP:
  411.                         switch(gadget->GadgetID)
  412.                         {
  413.                             case GD_SLEEP:
  414. gdsleep:                while(message=(struct IntuiMessage *)GetMsg(MainWnd->UserPort)) ReplyMsg((struct Message *)message);
  415.                                 CloseMainWindow();
  416.                                 CloseDownScreen();
  417.                                 SigWin=NULL;
  418.                                 LogFile(TYPE_HOTKEY,0);
  419.                                 MasterTime=0;
  420.                                 HDDriveOff(DRV_MASTER);
  421.                                 SlaveTime=0;
  422.                                 HDDriveOff(DRV_SLAVE);
  423.                                 goto skip;
  424.                                 break;
  425.                             case GD_ABORT:
  426. gdabort:                MasterTime=MASTERTIME;
  427.                                 SlaveTime=SLAVETIME;
  428. gdhide:                    while(message=(struct IntuiMessage *)GetMsg(MainWnd->UserPort)) ReplyMsg((struct Message *)message);
  429.                                 CloseMainWindow();
  430.                                 CloseDownScreen();
  431.                                 SigWin=NULL;
  432.                                 goto skip;
  433.                                 break;
  434.                             case GD_QUIT:
  435. gdquit:                    running=FALSE;
  436.                                 break;
  437.                         }
  438.                         break;
  439.                 }
  440.             }
  441.         }
  442.         if(signals & (1L<<broker_mp->mp_SigBit)) HandleCxMsg();
  443. skip:;
  444.     }
  445.  
  446. exitit:
  447.     LogFile(TYPE_END,0);
  448.  
  449.     if(MainWnd)
  450.     {
  451.         CloseMainWindow();
  452.         CloseDownScreen();
  453.         SigWin=NULL;
  454.     }
  455.     RemInt();
  456.     if(OldBeginIO) SetFunction(SCSIBase,DEV_BEGINIO,(unsigned long (*)())OldBeginIO);
  457.     if(broker) DeleteCxObjAll(broker);
  458.     if(broker_mp) DeleteMsgPort(broker_mp);
  459. }
  460.  
  461. void __saveds __asm MyBeginIO(register __a1 struct IORequest *io)
  462. {
  463.     MasterTime=MASTERTIME;
  464.     SlaveTime=SLAVETIME;
  465.     CallBeginIO(io);
  466. //    SpinUp=TRUE;
  467. }
  468.  
  469. int AddInt()
  470. {
  471.     if(TimerPort=CreatePort("HDSleep Port",0L))
  472.     {
  473.         if(!OpenDevice(TIMERNAME,UNIT_MICROHZ,(struct IORequest *)&TimerReq,0))
  474.         {
  475.             MasterTime=MASTERTIME;
  476.             SlaveTime=SLAVETIME;
  477.             TimerReq.tr_node.io_Message.mn_ReplyPort=TimerPort;
  478.             TimerReq.tr_node.io_Command=TR_ADDREQUEST;
  479.             TimerReq.tr_time.tv_secs=1;
  480.             TimerReq.tr_time.tv_micro=0;
  481.             TimerReq.tr_node.io_Error=0;
  482.             TimerReq.tr_node.io_Flags=0;
  483.             SendIO((struct IORequest *)&TimerReq);
  484.             return 1;
  485.         }
  486.     }
  487.     return 0;
  488. }
  489.  
  490. void RemInt()
  491. {
  492.     if(timerun) CloseDevice((struct IORequest *)&TimerReq);
  493.     if(TimerPort) DeletePort(TimerPort);
  494. }
  495.  
  496. void HandleCxMsg()
  497. {
  498.     while(cxmsg=(CxMsg *)GetMsg(broker_mp))
  499.     {
  500.         msgid  = CxMsgID(cxmsg);
  501.         msgtype= CxMsgType(cxmsg);
  502.         ReplyMsg((struct Message *)cxmsg);
  503.         switch(msgtype)
  504.         {
  505.             case CXM_IEVENT:
  506.                 switch(msgid)
  507.                 {
  508.                     case EVT_HOTKEY:
  509.                         LogFile(TYPE_HOTKEY,0);
  510.                         MasterTime=0;
  511.                         HDDriveOff(DRV_MASTER);
  512.                         SlaveTime=0;
  513.                         HDDriveOff(DRV_SLAVE);
  514.                         if(MainWnd)
  515.                         {
  516.                             CloseMainWindow();
  517.                             CloseDownScreen();
  518.                             SigWin=NULL;
  519.                         }
  520.                         break;
  521.                     case EVT_POPKEY:
  522.                         if(!MainWnd)
  523.                         {
  524.                             if(!SetupScreen())
  525.                             {
  526.                                 if(!OpenMainWindow())
  527.                                 {
  528.                                     SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  529.                                     GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  530.                                     GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  531.                                 }
  532.                             }
  533.                         }
  534.                         break;
  535.                 }
  536.                 break;
  537.             case CXM_COMMAND:
  538.                 switch(msgid)
  539.                 {
  540.                     case CXCMD_DISABLE:
  541.                         ActivateCxObj(broker,0L);
  542.                         break;
  543.                     case CXCMD_ENABLE:
  544.                         ActivateCxObj(broker,1L);
  545.                         break;
  546.                     case CXCMD_APPEAR:
  547.                         if(!MainWnd)
  548.                         {
  549.                             if(!SetupScreen())
  550.                             {
  551.                                 if(!OpenMainWindow())
  552.                                 {
  553.                                     SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  554.                                     GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  555.                                     GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  556.                                 }
  557.                             }
  558.                         }
  559.                         break;
  560.                     case CXCMD_DISAPPEAR:
  561.                         if(MainWnd)
  562.                         {
  563.                             CloseMainWindow();
  564.                             CloseDownScreen();
  565.                             SigWin=NULL;
  566.                         }
  567.                         break;
  568.                     case CXCMD_KILL:
  569.                     case CXCMD_UNIQUE:
  570.                         running=FALSE;
  571.                         break;
  572.                 }
  573.                 break;
  574.         }
  575.     }
  576. }
  577.  
  578. void RequestOK(char *napis)
  579. {
  580.     struct EasyStruct easyreq;
  581.     APTR bw=NULL;
  582.  
  583.     easyreq.es_StructSize=sizeof(struct EasyStruct);
  584.     easyreq.es_Flags=0;
  585.     easyreq.es_Title="About";
  586.     easyreq.es_TextFormat=napis;
  587.     easyreq.es_GadgetFormat="Ok";
  588.  
  589.     if(MainWnd) bw=BusyWindow(MainWnd);
  590.     EasyRequest(MainWnd,&easyreq,NULL,NULL);
  591.     if(bw) UnbusyWindow(bw);
  592. }
  593.  
  594. APTR BusyWindow(struct Window *Win)
  595. {
  596.     struct BusyWin *bw=NULL;
  597.  
  598.     if(Win)
  599.     {
  600.         if(bw=AllocVec(sizeof(struct BusyWin),MEMF_ANY))
  601.         {
  602.             bw->Win=Win;
  603.             InitRequester(&bw->Req);
  604.             Request(&bw->Req,bw->Win);
  605.             SetWindowPointer(bw->Win,WA_BusyPointer,TRUE,TAG_DONE);
  606.         }
  607.     }
  608.     return((APTR) bw);
  609. }
  610.  
  611. void UnbusyWindow(APTR bwp)
  612. {
  613.     struct BusyWin *bw;
  614.  
  615.     if(bwp)
  616.     {
  617.         bw=(struct BusyWin *)bwp;
  618.         EndRequest(&bw->Req,bw->Win);
  619.         SetWindowPointer(bw->Win,WA_Pointer,NULL,TAG_DONE);
  620.         FreeVec(bwp);
  621.     }
  622. }
  623.  
  624. void LogFile(UBYTE type,UBYTE hd)
  625. {
  626.     FILE *fh;
  627.     char texttime[100];
  628.     unsigned char clock[8];
  629.  
  630.     if(logfilestr[0])
  631.     {
  632.         if(fh=fopen(logfilestr,"a"))
  633.         {
  634.             getclk(clock);
  635.             sprintf(texttime,"%02ld-%02ld-%02ld %02ld:%02ld:%02ld",(ULONG)clock[3],(ULONG)clock[2],(ULONG)clock[1]+80,(ULONG)clock[4],(ULONG)clock[5],(ULONG)clock[6]);
  636.             switch(type)
  637.             {
  638.                 case TYPE_RUN:
  639.                     fprintf(fh,"%s  HDSleep started.\n",texttime);
  640.                     break;
  641.                 case TYPE_END:
  642.                     fprintf(fh,"%s  HDSleep exited.\n\n*********************\n\n",texttime);
  643.                     break;
  644. //            case TYPE_SPINUP:
  645. //                fprintf(fh,"%s  HD Spinup.\n",texttime);
  646. //                break;
  647.                 case TYPE_SPINDOWN:
  648.                     fprintf(fh,"%s  %s HD spindown after %ld seconds inactivity.\n",texttime,hd?"Slave":"Master",hd?SLAVETIME:MASTERTIME);
  649.                     break;
  650.                 case TYPE_HOTKEY:
  651.                     fprintf(fh,"%s  All HDs have been spindown by the user.\n",texttime);
  652.                     break;
  653.             }
  654.             fclose(fh);
  655.         }
  656.         switch(type)
  657.         {
  658.             case TYPE_SPINDOWN:
  659.             case TYPE_HOTKEY:
  660.                 Delay(3*50);        // Delay to write log
  661.                 break;
  662.         }
  663.     }
  664. }
  665.